
#ifndef RByte_h
#define RByte_h

#include "System/Object.h"
#include "System/IComparable.h"
#include "System/IFormattable.h"
#include "System/IConvertible.h"
#include "System/Generic/IComparable.h"
#include "System/Generic/IEquatable.h"
#include "System/Globalization/NumberStyles.h"

namespace Riccsson
{
	namespace System
	{
		// Summary:
		//     Represents an 8-bit unsigned integer.
		//[Serializable]
		//[ComVisible(true)]
		struct Byte
			: public Object
			, public Riccsson::System::IComparable
			, public Riccsson::System::IFormattable
			//, public Riccsson::System::IConvertible
			, public Riccsson::System::Generic::IComparable<byte>
			, public Riccsson::System::Generic::IEquatable<byte>
		{
			// Summary:
			//     Represents the largest possible value of a System.Byte. This field is constant.
			public: static const byte MaxValue = 255;
			//
			// Summary:
			//     Represents the smallest possible value of a System.Byte. This field is constant.
			public: static const byte MinValue = 0;

			// Summary:
			//     Compares this instance to a specified 8-bit unsigned integer and returns
			//     an indication of their relative values.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer to compare.
			//
			// Returns:
			//     A signed integer that indicates the relative order of this instance and value.Return
			//     Value Description Less than zero This instance is less than value. Zero This
			//     instance is equal to value. Greater than zero This instance is greater than
			//     value.
			public: int CompareTo(byte* value)
			{
				throw;
			}

			//
			// Summary:
			//     Compares this instance to a specified object and returns an indication of
			//     their relative values.
			//
			// Parameters:
			//   value:
			//     An object to compare, or null.
			//
			// Returns:
			//     A signed integer that indicates the relative order of this instance and value.Return
			//     Value Description Less than zero This instance is less than value. Zero This
			//     instance is equal to value. Greater than zero This instance is greater than
			//     value.-or- value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     value is not a System.Byte.
			public: int CompareTo(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns a value indicating whether this instance and a specified System.Byte
			//     object represent the same value.
			//
			// Parameters:
			//   obj:
			//     An object to compare to this instance.
			//
			// Returns:
			//     true if obj is equal to this instance; otherwise, false.
			public: bool Equals(byte* obj)
			{
				throw;
			}

			//
			// Summary:
			//     Returns a value indicating whether this instance is equal to a specified
			//     object.
			//
			// Parameters:
			//   obj:
			//     An object to compare with this instance, or null.
			//
			// Returns:
			//     true if obj is an instance of System.Byte and equals the value of this instance;
			//     otherwise, false.
			public: override bool Equals(const object* obj)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the hash code for this instance.
			//
			// Returns:
			//     A hash code for the current System.Byte.
			public: override int GetHashCode()
			{
				throw;
			}

			//
			// Summary:
			//     Returns the System.TypeCode for value type System.Byte.
			//
			// Returns:
			//     The enumerated constant, System.TypeCode.Byte.
			public: TypeCode GetTypeCode()
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string representation of a number to its System.Byte equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert. The string is interpreted using
			//     the System.Globalization.NumberStyles.Integer style.
			//
			// Returns:
			//     A byte value that is equivalent to the number contained in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not of the correct format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			public: static byte Parse(string* s)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string representation of a number in a specified culture-specific
			//     format to its System.Byte equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert. The string is interpreted using
			//     the System.Globalization.NumberStyles.Integer style.
			//
			//   provider:
			//     An object that supplies culture-specific parsing information about s. If
			//     provider is null, the thread current culture is used.
			//
			// Returns:
			//     A byte value that is equivalent to the number contained in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not of the correct format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			public: static byte Parse(string* s, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string representation of a number in a specified style to its
			//     System.Byte equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert. The string is interpreted using
			//     the style specified by style.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer.
			//
			// Returns:
			//     A byte value that is equivalent to the number contained in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not of the correct format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			//     -or-s includes non-zero, fractional digits.
			//
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is not
			//     a combination of System.Globalization.NumberStyles.AllowHexSpecifier and
			//     System.Globalization.NumberStyles.HexNumber values.
			public: static byte Parse(string s, Globalization::NumberStyles style)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string representation of a number in a specified style and culture-specific
			//     format to its System.Byte equivalent.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert. The string is interpreted using
			//     the style specified by style.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer.
			//
			//   provider:
			//     An object that supplies culture-specific information about the format of
			//     s. If provider is null, the thread current culture is used.
			//
			// Returns:
			//     A byte value that is equivalent to the number contained in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not of the correct format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			//     -or-s includes non-zero, fractional digits.
			//
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is not
			//     a combination of System.Globalization.NumberStyles.AllowHexSpecifier and
			//     System.Globalization.NumberStyles.HexNumber values.
			public: static byte Parse(string s, Globalization::NumberStyles style, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the current System.Byte object to its equivalent string
			//     representation.
			//
			// Returns:
			//     The string representation of the value of this object, which consists of
			//     a sequence of digits that range from 0 to 9 with no leading zeroes.
			//[SecuritySafeCritical]
			public: override GC_PTR<string> ToString()
			{
				throw;
			}

			//
			// Summary:
			//     Converts the numeric value of the current System.Byte object to its equivalent
			//     string representation using the specified culture-specific formatting information.
			//
			// Parameters:
			//   provider:
			//     An object that supplies culture-specific formatting information.
			//
			// Returns:
			//     The string representation of the value of this object in the format specified
			//     by the provider parameter.
			//[SecuritySafeCritical]
			public: GC_PTR<string> ToString(IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the current System.Byte object to its equivalent string
			//     representation using the specified format.
			//
			// Parameters:
			//   format:
			//     A numeric format string.
			//
			// Returns:
			//     The string representation of the current System.Byte object, formatted as
			//     specified by the format parameter.
			//
			// Exceptions:
			//   System.FormatException:
			//     format includes an unsupported specifier. Supported format specifiers are
			//     listed in the Remarks section.
			//[SecuritySafeCritical]
			public: GC_PTR<string> ToString(string* format)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the current System.Byte object to its equivalent string
			//     representation using the specified format and culture-specific formatting
			//     information.
			//
			// Parameters:
			//   format:
			//     A standard or custom numeric format string.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information.
			//
			// Returns:
			//     The string representation of the current System.Byte object, formatted as
			//     specified by the format and provider parameters.
			//
			// Exceptions:
			//   System.FormatException:
			//     format includes an unsupported specifier. Supported format specifiers are
			//     listed in the Remarks section.
			//[SecuritySafeCritical]
			public: GC_PTR<string> ToString(string* format, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Tries to convert the string representation of a number to its System.Byte
			//     equivalent, and returns a value that indicates whether the conversion succeeded.
			//
			// Parameters:
			//   s:
			//     A string that contains a number to convert. The string is interpreted using
			//     the System.Globalization.NumberStyles.Integer style.
			//
			//   result:
			//     When this method returns, contains the System.Byte value equivalent to the
			//     number contained in s if the conversion succeeded, or zero if the conversion
			//     failed. This parameter is passed uninitialized.
			//
			// Returns:
			//     true if s was converted successfully; otherwise, false.
			public: static bool TryParse(string* s, byte out result)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string representation of a number in a specified style and culture-specific
			//     format to its System.Byte equivalent. A return value indicates whether the
			//     conversion succeeded or failed.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert. The string is interpreted using
			//     the style specified by style.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information about s.
			//     If provider is null, the thread current culture is used.
			//
			//   result:
			//     When this method returns, contains the 8-bit unsigned integer value equivalent
			//     to the number contained in s if the conversion succeeded, or zero if the
			//     conversion failed. The conversion fails if the s parameter is null, is not
			//     of the correct format, or represents a number less than System.Byte.MinValue
			//     or greater than System.Byte.MaxValue. This parameter is passed uninitialized.
			//
			// Returns:
			//     true if s was converted successfully; otherwise, false.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is not
			//     a combination of System.Globalization.NumberStyles.AllowHexSpecifier and
			//     System.Globalization.NumberStyles.HexNumber values.
			public: static bool TryParse(string* s, Globalization::NumberStyles style, IFormatProvider* provider, byte out result)
			{
				throw;
			}
		};
	}
}

#endif